home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 / Ham Radio 2000.iso / ham2000 / tcp_ip / gracil / p10dvr / p10_at.c < prev    next >
C/C++ Source or Header  |  1992-09-07  |  21KB  |  867 lines
  1. /****************************************************************************
  2. *
  3. *            COPYRIGHT 1990,91,92 BY GRACILIS INC.
  4. *
  5. *             623 Palace St.
  6. *             Aurora, Il. 60506
  7. *
  8. *             (708)-801-8800        Office
  9. *             (708)-844-0183        (FAX - Support BBS)
  10. *
  11. * GRACILIS, INC., MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS 
  12. * SOFTWARE FOR ANY PURPOSE.  
  13. *
  14. * THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
  15. * 
  16. * Permission is granted for non-commercial use/distribution only, as long as
  17. * this copyright header is included intact and unaltered.
  18. *
  19. ******************************************************************************/
  20.  
  21.  
  22.  
  23. /************************************************************************
  24. *
  25. *
  26. * File: ipc.c
  27. *
  28. * Rev : 1.0
  29. *
  30. * Description:    
  31. *
  32. *    This File contains routines that implement PackeTen Switch's 
  33. *    inter-processor driver with an interface to KA9Q's TCP/IP suite.
  34. *
  35. *
  36. * Routines: 
  37. *
  38. *    ipc_attach    - Performs attach functions for TCP/IP, i.e.
  39. *                  attach the ipc driver to TCP/IP.
  40. *
  41. *    ipc_raw        - Applications' routine for transmitting
  42. *                  a message via ipc driver.
  43. *
  44. *    ipc_recv    - Applications' routine for receiving a message
  45. *                    from the ipc driver.
  46. *
  47. *    ipc_stat    - Applications' routine for "displaying" the
  48. *                  ipc driver statistics.
  49. *
  50. *    ipc_ioctl    - Set driver parameters.
  51. *
  52. *    ipc_stop    - Stop I/O
  53. *    
  54. *    ipc_init    - Initialize the ipc hardware.
  55. *
  56. *    ipc_txint    - Handles transmit complete interrupts.
  57. *
  58. *    ipc_rxint    - Handles receive complete interrupts.
  59. *
  60. *    ipc_entpt    - Interrupt entry point
  61. *
  62. */
  63.  
  64. /*
  65.     Note: As currently implemented, if the remote side of an IPC
  66.     link stops functioning, and we can not send our data to it,
  67.     eventually, all of NOS buffer memory will be used up.
  68.  
  69.     Some strategy needs be developed to handle this problem...
  70.     It is analagous to a link which cannot transmit due to
  71.     a continuously appearing  CARRIER on frequency.
  72.  
  73. */
  74. #include <stdio.h>
  75. #include <dos.h>
  76. #include "global.h"
  77. #include "pc.h"
  78. #include "config.h"
  79. #include "mbuf.h"
  80. #include "ax25.h"
  81. #include "iface.h"
  82. #include "lapb.h"
  83. #include "proc.h"
  84. #include "trace.h"
  85. #include "netuser.h"
  86. #include "proc.h"
  87. #include "pktdrvr.h"
  88. #include "commands.h"
  89. #include "devparam.h"
  90. #include "gracilis.h"
  91. #include "p10.h"
  92.  
  93. #ifdef OLD_KA9Q
  94. #else
  95. #define    tprintf printf
  96. #endif
  97.  
  98.  
  99. #ifdef PACKETEN_DEBUG
  100. extern long    recvcalls;
  101. extern long    rawcalls;
  102. #endif
  103.  
  104. extern UNI_DCB P10_udcb[];
  105.  
  106.  
  107. extern INTERRUPT (*P10oldvec) __ARGS((void)); /* Old vector contents */
  108. extern int16       P10_vec;        /* Vector number */
  109.  
  110. extern int16    P10Proc_id;        /* The PC is processor 2!!! */
  111.  
  112. extern     IPC     *P10Ipc;
  113. extern    int16    P10Pcport;
  114.  
  115. extern INTERRUPT (*P10handler) __ARGS((void));
  116.  
  117.  
  118. /********************************************************************
  119. *                        IPC_ATTACH                                *
  120. *                                                                  *
  121. * File: ipc.c                                                * 
  122. * Rev : 1.0                                      *
  123. *                                                                  *
  124. ********************************************************************
  125. *
  126. *
  127. * DESCRIPTION: 
  128. * -----------
  129. * Attaches the PackeTen Switch's ipc driver to NOS.
  130. *
  131. * ARGUMENTS:
  132. * ---------
  133. *    All argv's are strings
  134. * argv[0]: hardware type,  "ipc"  
  135. *
  136. * argv[1]: vector, e.g., "2"
  137. *
  138. * argv[2]: "0" = PACKETEN main card
  139. *       "1" = PACKETEN daughter card
  140. *       "2" = IBM PC side of IPC
  141. * argv[3]: interface "NAME"
  142. *
  143. * argv[4]: encap mode
  144. *
  145. * argv[5]: OPTIONAL - IPC memory base address
  146. *
  147. * argv[6]: OPTIONAL - PackeTen control Port address - Default 0x238
  148. *
  149. * argv[7]: OPTIONAL - Tx Queue Depth, num. of tx packets to allow in the 
  150. *              "to be transmitted queue" at one time. 
  151. * 
  152. * argv[8]: OPTIONAL - # of rx buffers to preallocate !!! NOT IMPLEMENTED
  153. *
  154. * argv[9]: OPTIONAL - Ip address
  155. *
  156. * RETURN VALUES:
  157. * -------------
  158. *  0 - success
  159. * -1 - failure, driver not attached and no memory left allocated
  160. *
  161. * GLOBAL INPUTS:
  162. * -------------
  163. *        
  164. * GLOBAL OUTPUTS:
  165. * --------------
  166. *
  167. * FUNCTIONS CALLED:
  168. * ----------------
  169. * tprintf
  170. * calloc
  171. * malloc
  172. * free
  173. *
  174. * IO:
  175. * --
  176. *
  177. *
  178. ******************************************************************/
  179.  
  180.  
  181. int
  182. ipc_attach(argc,argv,p)
  183. int argc;            
  184. char *argv[];
  185. void *p;                    /* new for NOS */
  186. {
  187.     extern struct iface *ifaces;
  188.     struct iface *intfc_p;
  189.     IPC_DCB *sp;
  190.     UNI_DCB *udcbp;
  191.     int devnum, an_ipc_is_attached;
  192.     int32 ipaddr;                /* new for NOS */
  193.     char    i_state;    /* saved state of the interrupt level */
  194.     int    i;        /* gen purpose counter ... etc */
  195.     struct ipcbuf *rxarea;
  196.     long base_addr;
  197.     int16    port;
  198.  
  199.     /* 
  200.      * validate input params 
  201.      */
  202.     if ( argc < 5 )
  203.     {
  204.  
  205.         tprintf("ipc_attach: too few arguments (%d) \r\n", argc);
  206.         tprintf("ipc <vector> <processor (dc|mc)> <name> <mode> [base addr] [ctl addr]\r\n");
  207.         tprintf("             [txQdepth] [rxbufs] [ip addr]\r\n");
  208.         return(-1);
  209.     }
  210.  
  211.  
  212. #ifdef PACKETEN_DEBUG
  213.  
  214.     tprintf("ipc_attach: argument count is %d\n",argc);
  215.     for(i=0;i<argc;i++)
  216.         tprintf("arg #%d: %s\n",i,argv[i]);
  217.     tprintf("\n\n");
  218. #endif
  219.  
  220.     /* set the udcb device # for this processor's ipc */
  221.     devnum = -1;
  222.     if(strcmpi(argv[2],"mc") == 0)   devnum = 0;
  223.     if(strcmpi(argv[2],"dc") == 0)   devnum = 1;
  224.     if(strcmpi(argv[2],"pc") == 0)   devnum = 2;
  225.  
  226.     if(devnum == -1)
  227.     {
  228.         tprintf("ipc_attach err: unknown processor id %s\r\n",argv[2]);
  229.         tprintf("Try 'mc' for PackeTen Main Card or 'dc' for Daughter Card.\n");
  230.         return(-1);
  231.     }
  232.  
  233.     if((devnum) == P10Proc_id)    /* Can't be same as Our local processor*/
  234.     {
  235.         tprintf("ipc_attach err: processor id %s is LOCAL!!!\r\n",argv[2]);
  236.         tprintf("Try 'mc' for PackeTen Main Card or 'dc' for Daughter Card.\n");
  237.         return(-1);
  238.     }
  239.  
  240.  
  241.     if ( if_lookup(argv[3]) != NULLIF )    /* new for NOS */
  242.     {
  243.         tprintf("Interface %s already exists \r\n", argv[3]);
  244.         return(-1);
  245.     }
  246.  
  247.     /* new for NOS, Set the IP address */
  248.     ipaddr = Ip_addr;            /* default value */
  249.     if ( argc >= 10  )
  250.         ipaddr = resolve(argv[9]);
  251.     if ( ipaddr == 0 )
  252.     {
  253.         tprintf(Noipaddr);
  254.         return(-1);
  255.     }
  256.  
  257.     if(argc >= 6)
  258.     {
  259. #ifdef PACKETEN_DEBUG
  260.         tprintf("Base address = %lx\n",(unsigned long)ghtol(argv[5]));
  261. #endif
  262.         P10Ipc = (IPC *)ghtol(argv[5]);
  263.         base_addr = ptol(P10Ipc);
  264.  
  265.         if(    (base_addr != 0x80000000) &&
  266.             (base_addr != 0x90000000) &&
  267.             (base_addr != 0xA0000000) &&
  268.             (base_addr != 0xC0000000) &&
  269.             (base_addr != 0xD0000000) &&
  270.             (base_addr != 0xE0000000) 
  271.           )
  272.         {
  273.             tprintf("Bad IPC base address specified: %lx\n",base_addr);
  274.             return(-1);
  275.         }
  276.  
  277.  
  278.     }
  279.  
  280.     /* Did the user specify a port address? */
  281.     if(argc >= 7)
  282.     {
  283.         if((port = atoi(argv[6])) == 0)
  284.         {
  285.             tprintf("Illegal Control Port address specified: %s\n",argv[6]);
  286.             return(-1);
  287.         }
  288.         else P10Pcport = port;
  289.     }
  290.  
  291.     /* Gracilis 7/25/92 DGL */
  292.     /* Be sure to enable the dual port RAM for release 2 CPU's */
  293.     ipc_mapin(P10Pcport);
  294.  
  295.  
  296.     udcbp = &P10_udcb[devnum];    /* dev num is index number!!! */
  297.  
  298.     /* See if already attached */
  299.     if ( udcbp->attached )
  300.     {
  301.         tprintf("ipc_attach error: IPC channel already attached; interface is %s\n", argv[3]); 
  302.         return(-1);
  303.     }
  304.  
  305.  
  306.     /* 
  307.      * try to allocate necessary memory 
  308.      */
  309.  
  310.     intfc_p = (struct iface *)calloc(1,sizeof(struct iface));
  311.     if ( intfc_p !=  (struct iface *)0 )
  312.     {
  313.         intfc_p->name = malloc((unsigned)strlen(argv[3])+2);
  314.         if (intfc_p->name != NULLCHAR )    
  315.         {
  316.             intfc_p->hwaddr = NULL;
  317.         }
  318.         else
  319.         {
  320.             free(intfc_p);
  321.             tprintf("ipc_attach error: no memory for interface name, size 7 bytes, interface %s", argv[3]);
  322.             return(-1);
  323.         }
  324.     }
  325.     else
  326.     {
  327.         tprintf("ipc_attach error: no memory for interface struct, size of %d, interface %s", sizeof(struct iface),argv[3]);
  328.         return(-1);
  329.     }
  330.  
  331.     /* allocate and clear the device control block */
  332.     sp = (IPC_DCB *)calloc(1,sizeof(IPC_DCB));
  333.     if ( sp == (IPC_DCB *)0 )
  334.     {
  335.         free(intfc_p->name);
  336.         free(intfc_p);
  337.         tprintf("ipc_attach error: no memory for device control block structure, size of %d, interface %s", sizeof(IPC_DCB),argv[3]);
  338.         return(-1);
  339.     }
  340.  
  341.  
  342.     /* this needs to be done BEFORE the buffers are allocated... */
  343.     /* DGL 4/17/90 */
  344.  
  345.     /* 7/25/92 DGL */
  346.     /* intfc_p->type = CL_AX25; */
  347.     /* attempt to set the encapsulation type */
  348.     /* This needs to be done before we preallocate */
  349.     /* receive buffers, since we have to indicate the */
  350.     /* encap type in the buffers for later use. */
  351.     /* Only allow type "IPC" or "AX25" */
  352.     if(((strcmpi(argv[4],"ax25") != 0) && 
  353.         (strcmpi(argv[4],"ipc") != 0)) ||
  354.        (setencap(intfc_p,argv[4]) != 0))
  355.     {
  356.         /* An invalid encap mode was specified... */
  357.         /* Just print a message and exit */
  358.         tprintf("Illegal mode specification: %s\n",argv[4]);
  359.         free(intfc_p->name);
  360.         free(intfc_p);
  361.         free(sp);
  362.         return(-1);
  363.     }
  364.  
  365.     /* preallocate rx buffers */
  366.     /* set the rxavailbufs parameter */
  367.     if ( argc >= 9 )
  368.         sp->rxavailbufs = atoi(argv[8]);
  369.     else
  370.         sp->rxavailbufs = IPC_BUF_CNT + 1;
  371.  
  372.     /* get the requested rx pre-allocated mbuf's */
  373.     sp->rxavailq = NULLBUF;
  374.  
  375.  
  376.     f_getavail(&(sp->rxavailq), (sp->rxavailbufs), IPC_BUF_SIZE, &(sp->rxavailcount), intfc_p, (bool)FALSE); 
  377.  
  378. #ifdef PACKETEN_DEBUG
  379. tprintf("ipc_attach: rxavailbufs is %d, rxavailcount is %d\n", sp->rxavailbufs, sp->rxavailcount); 
  380. #endif
  381.  
  382.     if(sp->rxavailcount < sp->rxavailbufs)
  383.     {
  384.         tprintf("ipc_attach: Insufficient Memory to preallocate rx buffers...\n");
  385.         free(intfc_p->name);
  386.         free(intfc_p);
  387.  
  388.         /* Now free all successfully allocated buffers... */    
  389.         while((sp->rxbufp = f_dequeavail(&sp->rxavailq,&sp->rxavailcount)) != NULLBUF)
  390.             free(sp->rxbufp);
  391.  
  392.         free(sp);
  393.         return(-1);
  394.     }
  395.     
  396.     /* setup the receive buffer pointer */
  397.     sp->rxbufp = f_dequeavail(&sp->rxavailq,&sp->rxavailcount);
  398.  
  399.     /*
  400.      * Setup the interface structure and link it to the list
  401.      * of interface structures.
  402.      */
  403.     /* the Ascii name of the driver unit */
  404.     strcpy(intfc_p->name,argv[3]);
  405.  
  406.     /* fill in this "Unit's" driver control block */
  407.  
  408.     intfc_p->mtu = (IPC_BUF_SIZE - MAX_AX25_HDR_LEN);
  409.     intfc_p->ioctl =  ipc_ioctl;
  410.     intfc_p->raw = ipc_raw;
  411.     intfc_p->stop = ipc_stop;
  412.     intfc_p->dev = devnum;
  413.     intfc_p->addr = ipaddr;
  414.  
  415.     /* new for NOS Mycall replaces (char *)&mycall */
  416.     intfc_p->hwaddr = mallocw(AXALEN);
  417.     memcpy(intfc_p->hwaddr,Mycall,AXALEN);  
  418.  
  419.  
  420.     /* lastly, but very importantly, put in the LL of interfaces */
  421.     intfc_p->next = Ifaces;
  422.     Ifaces = intfc_p;
  423.  
  424.  
  425.     /* 
  426.      * Initialize the unit's driver control block 
  427.      */
  428.     sp->iface = intfc_p;        /* new for NOS - save the iface */
  429.                     /* address for use in queueing */
  430.                     /* mbufs onto Hopper */
  431.     sp->destproc = (devnum);
  432.     sp->xmtq = (struct drvbuf *)0;
  433.     sp->xmtqtail = (struct drvbuf *)0;
  434.     sp->freem = (struct drvbuf *)0;
  435.  
  436.     if ( argc >= 8  )
  437.         sp->txq_depth = atoi(argv[7]);
  438.     else
  439.         sp->txq_depth = IPC_TX_DEPTH_DEFAULT;
  440.  
  441.  
  442.     /* no need to init stats because calloc zero-ed the sp */
  443.     sp->intcnt = 0;
  444.     sp->txcnt = 0;
  445.  
  446.     /*
  447.      *  Now for the hardware dependent initializations.
  448.      *
  449.      *  intfc_p->dev tells which unit/dev
  450.       *
  451.      */
  452. #ifdef PACKETEN_DEBUG
  453.     tprintf("ipc_attach: intfc_p->dev = %x config IPC HW \r\n", intfc_p->dev);
  454. #endif
  455.  
  456.  
  457.  
  458.     /* HERE WE start DIDDLING the actual hardware regs... */
  459.     /* So to be safe, NO ints... */    
  460.     i_state = dirps();
  461.  
  462.     /* reset all possible pending ints for IPC */
  463.     clrint302dc();
  464.     clrint302mc();
  465.  
  466.     switch(P10Proc_id)
  467.     {
  468.         case    0: switch(sp->destproc)
  469.                {
  470.                 case    1: sp->rxarea = (struct ipcbuf *)P10Ipc->proc[0].proc_buf[0];
  471.                        sp->rxcontrol = (uchar *)&P10Ipc->proc[0].control[0];
  472.                        sp->txcontrol = (uchar *)&P10Ipc->proc[1].control[0];
  473.                        sp->txarea = (struct ipcbuf *)P10Ipc->proc[1].proc_buf[0];
  474.                        break;
  475.  
  476.                 case    2: sp->rxarea = (struct ipcbuf *)P10Ipc->proc[0].proc_buf[1];
  477.                        sp->rxcontrol = (uchar *)&P10Ipc->proc[0].control[1];
  478.                        sp->txcontrol = (uchar *)&P10Ipc->proc[2].control[0];
  479.                        sp->txarea = (struct ipcbuf *)P10Ipc->proc[2].proc_buf[0];
  480.                        break;
  481.  
  482.                 default:   break;
  483.                }
  484.                break;
  485.  
  486.         case    1: switch(sp->destproc)
  487.                {
  488.                 case    0: sp->rxarea = (struct ipcbuf *)P10Ipc->proc[1].proc_buf[0];
  489.                        sp->rxcontrol = (uchar *)&P10Ipc->proc[1].control[0];
  490.                        sp->txcontrol = (uchar *)&P10Ipc->proc[0].control[0];
  491.                        sp->txarea = (struct ipcbuf *)P10Ipc->proc[0].proc_buf[0];
  492.                        break;
  493.  
  494.                 case    2: sp->rxarea = (struct ipcbuf *)P10Ipc->proc[1].proc_buf[1];
  495.                        sp->rxcontrol = (uchar *)&P10Ipc->proc[1].control[1];
  496.                        sp->txcontrol = (uchar *)&P10Ipc->proc[2].control[1];
  497.                        sp->txarea = (struct ipcbuf *)P10Ipc->proc[2].proc_buf[1];
  498.                        break;
  499.  
  500.                 default:   break;
  501.                }
  502.                break;
  503.  
  504.         case    2: switch(sp->destproc)
  505.                {
  506.                 case    0: sp->rxarea = (struct ipcbuf *)P10Ipc->proc[2].proc_buf[0];
  507.                        sp->rxcontrol = (uchar *)&P10Ipc->proc[2].control[0];
  508.                        sp->txcontrol = (uchar *)&P10Ipc->proc[0].control[1];
  509.                        sp->txarea = (struct ipcbuf  *)P10Ipc->proc[0].proc_buf[1];
  510.                        break;
  511.  
  512.                 case    1: sp->rxarea = (struct ipcbuf *)P10Ipc->proc[2].proc_buf[1];
  513.                        sp->rxcontrol = (uchar *)&P10Ipc->proc[2].control[1];
  514.                        sp->txcontrol = (uchar *)&P10Ipc->proc[1].control[1];
  515.                        sp->txarea = (struct ipcbuf *)P10Ipc->proc[1].proc_buf[1];
  516.                        break;
  517.  
  518.                 default:   break;
  519.                }
  520.                break;
  521.  
  522.  
  523.         default    :    tprintf("Invalid processor ID!!!\n");
  524.                 break;
  525.     }
  526.  
  527.  
  528.  
  529.     /* Initialize IPC RX buffer descriptors */
  530.  
  531.     rxarea = sp->rxarea;
  532.  
  533. #ifdef PACKETEN_DEBUG
  534.     restore(i_state);
  535.     tprintf("rxarea's at:\n");
  536. #endif
  537.     for(i=0;i<IPC_BUF_CNT;i++)
  538.     {
  539. #ifdef PACKETEN_DEBUG
  540.     tprintf("%d at %lx;  ",i, &rxarea[i]);
  541. #endif
  542.         /* mark the buffers inactive */
  543.         rxarea[i].active = (unsigned char)FALSE;
  544.         rxarea[i].msbcnt = (unsigned char)0;
  545.         rxarea[i].lsbcnt = (unsigned char)0;
  546.     }
  547. #ifdef PACKETEN_DEBUG
  548.     tprintf("\n");
  549.     fflush(stdout);
  550.     i_state = dirps();
  551. #endif
  552.     an_ipc_is_attached = FALSE;
  553.                 /* 0,1,2 are IPC chan/dev */
  554.     for (i=0; i<P10_MAXIPC; i++)        
  555.         if (P10_udcb[i].type == IPC_LINK) an_ipc_is_attached = TRUE;
  556.  
  557.  
  558.     /* only set the vector if no IPC link is attached */
  559.     if ( an_ipc_is_attached == FALSE )
  560.     {
  561.         /* tell other processors this processor is talking */
  562.         P10Ipc->active[P10Proc_id] = TRUE;
  563.  
  564.         /* Save old vector and write new vector */
  565.         P10_vec = htoi(argv[1]);
  566.         P10oldvec = getirq(P10_vec);
  567.  
  568.         /* Write ipc's interrupt vector */
  569.         if (setirq(P10_vec, P10handler) == -1)
  570.         {
  571.             tprintf("ipc_attach err:IRQ %u out of range\n",P10_vec);
  572.             free(intfc_p->name);
  573.             free(intfc_p);
  574.             /* Now free all successfully allocated buffers... */    
  575.             while ( (sp->rxbufp = f_dequeavail(&sp->rxavailq,&sp->rxavailcount)) != NULLBUF)
  576.                 free(sp->rxbufp);
  577.  
  578.             free(sp);
  579.             restore(i_state);
  580.             return(-1);
  581.         }
  582.     }
  583.  
  584.     /* send control msg to other end, tell him I reset my ipc link */
  585.  
  586. #ifdef PACKETEN_DEBUG
  587.     restore(i_state);
  588.     tprintf("sp->txcontrol = %lx\n",sp->txcontrol);
  589.     fflush(stdout);
  590.     i_state = dirps();
  591. #endif
  592.     *sp->txcontrol = IPC_RESET;
  593.     sp->txindex = sp->rxindex = 0;    
  594.     *sp->rxcontrol = 0;
  595.  
  596.     /* force an interrupt to destination processor, to make him see */
  597.     /* my control message */
  598.  
  599.     /* If the destination is the "Main Card"... */
  600.  
  601.     if(sp->destproc == 0) 
  602.         int302mc();
  603.     else      /* otherwise interrupt daughter 302 card */
  604.         int302dc();
  605.  
  606.     /* 
  607.      *  Universal Driver Control Block and 
  608.      *  Vector related initializations
  609.      */
  610.     udcbp->attached = TRUE;
  611.     udcbp->type = IPC_LINK;
  612.  
  613.     /* set address of the unit's driver control block */
  614.     udcbp->dcbp = (char *)sp;
  615.  
  616.     /* enable general ints */
  617.     restore(i_state);
  618.  
  619.     /* new for NOS - start the two processes needed by the */
  620.     /* sync driver; one is for getting pre-allocated buffers */
  621.     /* the other is for kicking the transmitter after its */
  622.     /* timer has expired or when it needs a transmitted */
  623.     /* message free-ed.  P.S. must do after attached set to TRUE */
  624. #ifdef PACKETEN_DEBUG
  625.     tprintf("ipc_attach: calling newproc for ipc_rxavget \n");
  626. #endif
  627.     sp->rxavproc = newproc("ipc rxavget",150,ipc_rxavget,devnum,NULL,NULL,0);
  628.  
  629. #ifdef PACKETEN_DEBUG
  630.     tprintf("ipc_attach: calling newproc for ipc_freetx \n");
  631. #endif
  632.     sp->freetxproc = newproc("ipc freetx",150,ipc_freetx,devnum,NULL,NULL,0);
  633.  
  634.  
  635.     /* DONE */
  636. #ifdef PACKETEN_DEBUG
  637.     tprintf("ipc_attach: All done!!! \n");
  638. #endif
  639.  
  640.     if ( an_ipc_is_attached == FALSE )
  641.         maskon(P10_vec);
  642.  
  643.     return(0);
  644.  }
  645. /*
  646.  * End of ipc_attach()
  647.  ******************************************************************/
  648.  
  649. /* 
  650.  * Display a PackeTen Switch Inter-Processor Communications channel's 
  651.  * statistics.
  652.  */
  653. int
  654. doipcstat(argc,argv,p)
  655. int argc;            
  656. char *argv[];
  657. void *p;                    /* new for NOS */
  658. {
  659. IPC_DCB *dcbp;
  660. UNI_DCB *udcbp;
  661. int16 dev;
  662.  
  663.     /* Header for the IPC channel's on the card */
  664.     tprintf("\n          PackeTen Switch Inter-Processor Comm Channel Statistics\n\n");
  665.     tprintf("Name/To   RxPacks   RxNoBufs   TxPacks    TxFlush   IntCnt    TxqDepth  RxAvail\n");
  666.     tprintf("-------  ---------  --------  ---------  --------  ---------  --------  -------\n");
  667.  
  668.     for (dev=0, udcbp = &P10_udcb[0]; dev < P10_MAXIPC; udcbp++, dev++) 
  669.     {
  670.         if ( udcbp->type == IPC_LINK )
  671.         {
  672.             dcbp = (IPC_DCB *)udcbp->dcbp;
  673.  
  674. /*            tprintf("%4s/%2s  %9.9d  %8.8ld  %9.9ld  %8.8ld  %9.9ld  %8.8ld  %7.7ld\n", 
  675. */
  676.             tprintf("%4s/%2s  %#9lu  %#8u  %#9lu  %#8u  %#9lu  %#8u  %#7u\n", 
  677.  
  678.                    dcbp->iface->name, 
  679.                    ((dev == 5)?"MC": (dev == 6)?"DC" : "PC"),
  680.                    dcbp->rxpackcnt,
  681.                    dcbp->nobufs,
  682.                    dcbp->txpackcnt,
  683.                    dcbp->txflush,
  684.                    dcbp->intcnt,
  685.                    dcbp->txq_depth,
  686.                    dcbp->rxavailcount);
  687.         }
  688.         
  689.     }   /* end of for loop */
  690.  
  691.     tprintf("\n");
  692.     return(0);
  693. }
  694.  
  695.  
  696. /* Subroutine to set kiss params in channel tables */
  697. int32
  698. ipc_ioctl(iface,cmd,set,val)
  699. struct iface *iface;
  700. int cmd;
  701. int set;
  702. int32 val;
  703. {
  704.     IPC_DCB *dcbp;
  705.  
  706.     dcbp = (IPC_DCB *)P10_udcb[iface->dev].dcbp;
  707.  
  708.     switch(cmd){
  709.     case PARAM_RXBUFS:
  710.         if(set)
  711.         {
  712.             dcbp->rxavailbufs = (int16)val;
  713.  
  714.             /* signal the process which */
  715.             /* allocates the rx buffers */
  716.             psignal(&ipc_bufpp[dcbp->destproc],1);
  717.         }
  718.  
  719.         return dcbp->rxavailbufs;
  720.  
  721.     case PARAM_TXQMAX:
  722.         if(set)
  723.             dcbp->txq_depth = (int16)val;
  724.         return dcbp->txq_depth;
  725.  
  726.     }
  727.     return -1;
  728. }
  729.  
  730. /* 
  731.  *  Stop I/O
  732.  */
  733. int
  734. ipc_stop(intfcp)
  735. struct iface *intfcp;
  736. {
  737. IPC_DCB  *sp;
  738. int16 dev;
  739. UNI_DCB *udcbp;
  740. int16    i_state, i, an_ipc_is_attached;
  741. struct drvbuf *xbufp, *tmpptr;
  742. struct mbuf *tmpmbufp;
  743.  
  744.     dev = intfcp->dev;
  745.     udcbp = &P10_udcb[dev];        /* dev num is index number!!! */
  746.  
  747.     if ( udcbp->attached != TRUE )
  748.     {
  749.         tprintf("ipc_stop err: Device already stopped/de-attached!!\n");
  750.         return(0);
  751.     }
  752.  
  753.           sp = (IPC_DCB *)P10_udcb[dev].dcbp;
  754.  
  755.     /* Turn off interrupts */
  756.     i_state = dirps();
  757.  
  758.     /* mark ipc as available - do it now for if below */
  759.     udcbp->attached = FALSE;
  760.     udcbp->type = 0;
  761.     udcbp->dcbp = NULL;
  762.  
  763.  
  764.     an_ipc_is_attached = FALSE;
  765.     for (i=0; i<P10_MAXIPC; i++)
  766.         if (P10_udcb[i].type == IPC_LINK)
  767.             an_ipc_is_attached = TRUE;
  768.  
  769.     /* when both IPC interfaces are stopped - tell other */
  770.     /* processors' this processor ain't talking */
  771.     if ( an_ipc_is_attached == FALSE )
  772.     {
  773.         /* tell the other processors this processor's IPC */
  774.         /* is closed */
  775.         P10Ipc->active[P10Proc_id] = FALSE;
  776.  
  777.         /* Turn off interrupts */
  778.         maskoff(P10_vec);
  779.  
  780.         /* Restore interrupt vector used by IPC handler */
  781.         setirq(P10_vec, P10oldvec); 
  782.     }
  783.  
  784.     restore(i_state);
  785.  
  786.     /* kill off the support processes */
  787.     /* so they don't allocate memory */
  788.     /* whils't we're freeing it */
  789.  
  790.     killproc(sp->rxavproc);
  791.     killproc(sp->freetxproc);
  792.  
  793.  
  794.     /* 
  795.      * Flush all buffers and queue's
  796.        */
  797.  
  798.  
  799.     /* free preallocated rx buffers on the rx available queue */    
  800.  
  801.     while((tmpmbufp = f_dequeavail(&sp->rxavailq,&sp->rxavailcount)) != NULLBUF)
  802.         free(tmpmbufp);
  803.  
  804.     /* free up any pending transmit buffers... */
  805.     while(sp->xmtq != (struct drvbuf *)0 )
  806.     {
  807.         tmpptr = sp->xmtq->next;
  808.         free(sp->xmtq);
  809.         sp->xmtq = tmpptr;
  810.     }
  811.  
  812.     /* Free any previously sent frames, which are in the waiting to be */
  813.     /* free'd queue */
  814.  
  815.     /* disable ints here to get queue head... */
  816.     i_state = dirps();            /* seems unecessary */
  817.     xbufp = sp->freem;
  818.     sp->freem = (struct drvbuf *)0;
  819.     restore(i_state);
  820.  
  821.     /* Here xbufp is a "to be free'd"  */
  822.     /* queue pointer" */
  823.     /* now free memory of all the xmitted messages */
  824.     while ( xbufp != (struct drvbuf *)0 )
  825.     {
  826.         tmpptr = xbufp->next;
  827.         free((char *)xbufp);
  828.         xbufp = tmpptr;
  829.     }
  830.  
  831.  
  832.     /*
  833.      * Deallocate other driver related memory structures 
  834.      */
  835.     if ( sp->rxbufp != NULLBUF )
  836.          free(sp->rxbufp);
  837.     free(sp);
  838.  
  839.     return(0);
  840. }
  841.  
  842. /* Convert hex-ascii to integer */
  843. static long int
  844. ghtol(s)
  845. char *s;
  846. {
  847.     long int i = 0;
  848.     char c;
  849.  
  850.     while((c = *s++) != '\0'){
  851.         if(c == 'x')
  852.             continue;    /* allow 0x notation */
  853.         if(c == ':')
  854.             continue;    /* allow : for seg:offset notation */
  855.         if('0' <= c && c <= '9')
  856.             i = (i * 16) + (c - '0');
  857.         else if('a' <= c && c <= 'f')
  858.             i = (i * 16) + (c - 'a' + 10);
  859.         else if('A' <= c && c <= 'F')
  860.             i = (i * 16) + (c - 'A' + 10);
  861.         else
  862.             break;
  863.     }
  864.     return i;
  865. }
  866.  
  867.